package com.hexingmo.dawn.lang;

import java.util.Collection;

/**
 * 断言工具类，提供常用的参数校验方法
 * 
 * <p>该工具类包含一系列静态方法，用于在方法入口处对参数进行校验，
 * 如果参数不符合要求则抛出相应的异常。这些方法可以帮助开发者
 * 快速实现参数校验，提高代码的健壮性和可读性。</p>
 * 
 * <h3>使用场景：</h3>
 * <ul>
 *   <li>方法参数校验</li>
 *   <li>构造函数参数校验</li>
 *   <li>业务逻辑前置条件校验</li>
 * </ul>
 * 
 * <h3>设计原则：</h3>
 * <ul>
 *   <li>所有方法均为静态方法，便于直接调用</li>
 *   <li>校验失败时抛出IllegalArgumentException异常</li>
 *   <li>提供重载方法，支持自定义错误消息</li>
 *   <li>保持方法命名语义清晰，易于理解</li>
 * </ul>
 * 
 * @author He Xing Mo
 * @since 1.0
 */
public class Assert {

    /**
     * 私有构造函数，防止实例化
     * 
     * <p>作为工具类，Assert不应该被实例化。
     * 如果尝试通过反射或其他方式创建实例，
     * 将抛出IllegalStateException异常。</p>
     * 
     * @throws IllegalStateException 当尝试实例化该类时抛出
     */
    private Assert() {
        throw new IllegalStateException("Static utility classes do not support instantiation");
    }

    /**
     * 校验对象不为null
     * 
     * <p>当传入的对象为null时，抛出IllegalArgumentException异常，
     * 异常消息为默认值"the object argument must not be null"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>方法参数校验</li>
     *   <li>字段初始化校验</li>
     *   <li>业务逻辑前置条件校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 在方法开始处校验参数
     * public void processUser(User user) {
     *     Assert.notNull(user);
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param object 待校验的对象
     * @throws IllegalArgumentException 当对象为null时抛出
     */
    public static void notNull(Object object) {
        notNull(object, "the object argument must not be null");
    }

    /**
     * 校验对象不为null（支持自定义错误消息）
     * 
     * <p>当传入的对象为null时，抛出IllegalArgumentException异常，
     * 异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的参数校验</li>
     *   <li>多参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processUser(User user) {
     *     Assert.notNull(user, "用户对象不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void transfer(User from, User to) {
     *     Assert.notNull(from, "转出用户不能为空");
     *     Assert.notNull(to, "转入用户不能为空");
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param object 待校验的对象
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当对象为null时抛出
     */
    public static void notNull(Object object, String message) {
        if (object == null) {
            throw new IllegalArgumentException(message);
        }
    }
    
    /**
     * 校验集合不为null且不为空
     * 
     * <p>当传入的集合为null或为空（size为0）时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "the collection must not be null or empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的集合类型</li>
     *   <li>确保集合包含至少一个元素</li>
     *   <li>业务逻辑前置条件校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验列表参数不为空
     * public void processUsers(List<User> users) {
     *     Assert.notEmpty(users);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验集合至少包含一个元素
     * public void calculateAverage(List<Integer> numbers) {
     *     Assert.notEmpty(numbers);
     *     // 计算平均值逻辑
     * }
     * }</pre>
     * 
     * @param coll 待校验的集合
     * @throws IllegalArgumentException 当集合为null或为空时抛出
     */
    public static void notEmpty(Collection<?> coll) {
        notEmpty(coll , "the collection must not be null or empty");
    }
    
    /**
     * 校验集合不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的集合为null或为空（size为0）时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的集合校验</li>
     *   <li>多集合参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processUsers(List<User> users) {
     *     Assert.notEmpty(users, "用户列表不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void compareLists(List<String> list1, List<String> list2) {
     *     Assert.notEmpty(list1, "第一个列表不能为空");
     *     Assert.notEmpty(list2, "第二个列表不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param coll 待校验的集合
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当集合为null或为空时抛出
     */
    public static void notEmpty(Collection<?> coll, String message) {
        if (coll == null || coll.isEmpty()) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验byte数组不为null且不为空
     * 
     * <p>当传入的byte数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "the byte array must not be null or empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的byte数组类型</li>
     *   <li>确保byte数组包含至少一个字节</li>
     *   <li>二进制数据处理相关业务逻辑校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验字节数组参数不为空
     * public void processBytes(byte[] data) {
     *     Assert.notEmpty(data);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验字节数组至少包含一个字节
     * public void calculateChecksum(byte[] bytes) {
     *     Assert.notEmpty(bytes);
     *     // 计算校验和逻辑
     * }
     * }</pre>
     * 
     * @param bytes 待校验的byte数组
     * @throws IllegalArgumentException 当byte数组为null或为空时抛出
     */
    public static void notEmpty(byte[] bytes) {
        notEmpty(bytes , "the byte array must not be null or empty");
    }

    /**
     * 校验byte数组不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的byte数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的byte数组校验</li>
     *   <li>多byte数组参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processBytes(byte[] data) {
     *     Assert.notEmpty(data, "数据字节数组不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void compareBytes(byte[] data1, byte[] data2) {
     *     Assert.notEmpty(data1, "第一个字节数组不能为空");
     *     Assert.notEmpty(data2, "第二个字节数组不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param bytes 待校验的byte数组
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当byte数组为null或为空时抛出
     */
    public static void notEmpty(byte[] bytes, String message) {
        if (bytes == null || bytes.length == 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验int数组不为null且不为空
     * 
     * <p>当传入的int数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "int array must not be empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的int数组类型</li>
     *   <li>确保int数组包含至少一个元素</li>
     *   <li>业务逻辑前置条件校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验int数组参数不为空
     * public void processNumbers(int[] numbers) {
     *     Assert.notEmpty(numbers);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验int数组至少包含一个元素
     * public void calculateSum(int[] values) {
     *     Assert.notEmpty(values);
     *     // 计算总和逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的int数组
     * @throws IllegalArgumentException 当int数组为null或为空时抛出
     */
    public static void notEmpty(int[] array) {
        notEmpty(array , "int array must not be empty");
    }

    /**
     * 校验int数组不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的int数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的int数组校验</li>
     *   <li>多int数组参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processNumbers(int[] numbers) {
     *     Assert.notEmpty(numbers, "数字数组不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void compareArrays(int[] array1, int[] array2) {
     *     Assert.notEmpty(array1, "第一个数组不能为空");
     *     Assert.notEmpty(array2, "第二个数组不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的int数组
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当int数组为null或为空时抛出
     */
    public static void notEmpty(int[] array, String message) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验long数组不为null且不为空
     * 
     * <p>当传入的long数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "long array must not be empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的long数组类型</li>
     *   <li>确保long数组包含至少一个元素</li>
     *   <li>大整数计算、时间戳处理等业务逻辑校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验long数组参数不为空
     * public void processTimestamps(long[] timestamps) {
     *     Assert.notEmpty(timestamps);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验long数组至少包含一个元素
     * public void calculateSum(long[] values) {
     *     Assert.notEmpty(values);
     *     // 计算总和逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的long数组
     * @throws IllegalArgumentException 当long数组为null或为空时抛出
     */
    public static void notEmpty(long[] array) {
        notEmpty(array , "long array must not be empty");
    }

    /**
     * 校验long数组不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的long数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的long数组校验</li>
     *   <li>多long数组参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processTimestamps(long[] timestamps) {
     *     Assert.notEmpty(timestamps, "时间戳数组不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void compareTimestamps(long[] startTimes, long[] endTimes) {
     *     Assert.notEmpty(startTimes, "开始时间数组不能为空");
     *     Assert.notEmpty(endTimes, "结束时间数组不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的long数组
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当long数组为null或为空时抛出
     */
    public static void notEmpty(long[] array, String message) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验short数组不为null且不为空
     * 
     * <p>当传入的short数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "short array must not be empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的short数组类型</li>
     *   <li>确保short数组包含至少一个元素</li>
     *   <li>音频处理、图像处理、端口号列表等业务逻辑校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验short数组参数不为空
     * public void processAudioSamples(short[] samples) {
     *     Assert.notEmpty(samples);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验short数组至少包含一个元素
     * public void validatePorts(short[] ports) {
     *     Assert.notEmpty(ports);
     *     // 端口验证逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的short数组
     * @throws IllegalArgumentException 当short数组为null或为空时抛出
     */
    public static void notEmpty(short[] array) {
        notEmpty(array , "short array must not be empty");
    }

    /**
     * 校验short数组不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的short数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的short数组校验</li>
     *   <li>多short数组参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processAudioSamples(short[] samples) {
     *     Assert.notEmpty(samples, "音频样本数组不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void compareSamples(short[] leftChannel, short[] rightChannel) {
     *     Assert.notEmpty(leftChannel, "左声道样本不能为空");
     *     Assert.notEmpty(rightChannel, "右声道样本不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的short数组
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当short数组为null或为空时抛出
     */
    public static void notEmpty(short[] array, String message) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验char数组不为null且不为空
     * 
     * <p>当传入的char数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "char array must not be empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的char数组类型</li>
     *   <li>确保char数组包含至少一个字符</li>
     *   <li>字符串处理、文本分析、字符编码等业务逻辑校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验char数组参数不为空
     * public void processText(char[] text) {
     *     Assert.notEmpty(text);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验char数组至少包含一个字符
     * public void analyzeCharacters(char[] chars) {
     *     Assert.notEmpty(chars);
     *     // 字符分析逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的char数组
     * @throws IllegalArgumentException 当char数组为null或为空时抛出
     */
    public static void notEmpty(char[] array) {
        notEmpty(array , "char array must not be empty");
    }

    /**
     * 校验char数组不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的char数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的char数组校验</li>
     *   <li>多char数组参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processText(char[] text) {
     *     Assert.notEmpty(text, "文本内容不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void compareTexts(char[] text1, char[] text2) {
     *     Assert.notEmpty(text1, "第一个文本不能为空");
     *     Assert.notEmpty(text2, "第二个文本不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的char数组
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当char数组为null或为空时抛出
     */
    public static void notEmpty(char[] array, String message) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验float数组不为null且不为空
     * 
     * <p>当传入的float数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "float array must not be empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的float数组类型</li>
     *   <li>确保float数组包含至少一个元素</li>
     *   <li>浮点数计算、科学计算、坐标处理等业务逻辑校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验float数组参数不为空
     * public void processCoordinates(float[] coordinates) {
     *     Assert.notEmpty(coordinates);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验float数组至少包含一个元素
     * public void calculateAverage(float[] values) {
     *     Assert.notEmpty(values);
     *     // 计算平均值逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的float数组
     * @throws IllegalArgumentException 当float数组为null或为空时抛出
     */
    public static void notEmpty(float[] array) {
        notEmpty(array , "float array must not be empty");
    }

    /**
     * 校验float数组不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的float数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的float数组校验</li>
     *   <li>多float数组参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processCoordinates(float[] coordinates) {
     *     Assert.notEmpty(coordinates, "坐标数组不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void compareCoordinates(float[] coords1, float[] coords2) {
     *     Assert.notEmpty(coords1, "第一个坐标数组不能为空");
     *     Assert.notEmpty(coords2, "第二个坐标数组不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的float数组
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当float数组为null或为空时抛出
     */
    public static void notEmpty(float[] array, String message) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验double数组不为null且不为空
     * 
     * <p>当传入的double数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "double array must not be empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的double数组类型</li>
     *   <li>确保double数组包含至少一个元素</li>
     *   <li>高精度数值计算、金融计算、统计分析等业务逻辑校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验double数组参数不为空
     * public void processPrices(double[] prices) {
     *     Assert.notEmpty(prices);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验double数组至少包含一个元素
     * public void calculateStatistics(double[] values) {
     *     Assert.notEmpty(values);
     *     // 统计计算逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的double数组
     * @throws IllegalArgumentException 当double数组为null或为空时抛出
     */
    public static void notEmpty(double[] array) {
        notEmpty(array , "double array must not be empty");
    }

    /**
     * 校验double数组不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的double数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的double数组校验</li>
     *   <li>多double数组参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processPrices(double[] prices) {
     *     Assert.notEmpty(prices, "价格数组不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void comparePrices(double[] oldPrices, double[] newPrices) {
     *     Assert.notEmpty(oldPrices, "旧价格数组不能为空");
     *     Assert.notEmpty(newPrices, "新价格数组不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的double数组
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当double数组为null或为空时抛出
     */
    public static void notEmpty(double[] array, String message) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验boolean数组不为null且不为空
     * 
     * <p>当传入的boolean数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "boolean array must not be empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的boolean数组类型</li>
     *   <li>确保boolean数组包含至少一个元素</li>
     *   <li>条件判断、状态管理、权限控制、标志位等业务逻辑校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验boolean数组参数不为空
     * public void processFlags(boolean[] flags) {
     *     Assert.notEmpty(flags);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验boolean数组至少包含一个元素
     * public void checkPermissions(boolean[] permissions) {
     *     Assert.notEmpty(permissions);
     *     // 权限检查逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的boolean数组
     * @throws IllegalArgumentException 当boolean数组为null或为空时抛出
     */
    public static void notEmpty(boolean[] array) {
        notEmpty(array , "boolean array must not be empty");
    }

    /**
     * 校验boolean数组不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的boolean数组为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的boolean数组校验</li>
     *   <li>多boolean数组参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processFlags(boolean[] flags) {
     *     Assert.notEmpty(flags, "标志位数组不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void compareFlags(boolean[] flags1, boolean[] flags2) {
     *     Assert.notEmpty(flags1, "第一个标志位数组不能为空");
     *     Assert.notEmpty(flags2, "第二个标志位数组不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param array 待校验的boolean数组
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当boolean数组为null或为空时抛出
     */
    public static void notEmpty(boolean[] array, String message) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException(message);
        }
    }
    
    /**
     * 校验两个对象是否相等
     * 
     * <p>当两个对象不相等时，抛出IllegalArgumentException异常，
     * 异常消息为默认值"the objects must be equal"。</p>
     * 
     * <h3>相等性判断规则：</h3>
     * <ul>
     *   <li>如果两个对象都为null，则认为相等</li>
     *   <li>如果其中一个对象为null，另一个不为null，则认为不相等</li>
     *   <li>如果两个对象都不为null，则通过{@link Object#equals(Object)}方法判断是否相等</li>
     * </ul>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>业务逻辑中需要确保两个值相等</li>
     *   <li>验证计算结果是否符合预期</li>
     *   <li>确认两个对象引用指向相同的值</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验两个字符串是否相等
     * public void validateName(String expected, String actual) {
     *     Assert.notEquals(expected, actual);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验计算结果是否正确
     * public void validateCalculation(int expected, int actual) {
     *     Assert.notEquals(expected, actual);
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param obj1 待比较的第一个对象
     * @param obj2 待比较的第二个对象
     * @throws IllegalArgumentException 当两个对象不相等时抛出
     */
    public static void notEquals(Object obj1, Object obj2) {
        if (obj1 == null && obj2 == null) {
            return;
        }
        if (obj1 == null || obj2 == null) {
            throw new IllegalArgumentException("the objects must not be null");
        }
        if (!obj1.equals(obj2)) {
            throw new IllegalArgumentException("the objects must be equal");
        }
    }
    
    /**
     * 校验两个对象是否相等（支持自定义错误消息）
     * 
     * <p>当两个对象不相等时，抛出IllegalArgumentException异常，
     * 异常消息为指定的自定义消息。</p>
     * 
     * <h3>相等性判断规则：</h3>
     * <ul>
     *   <li>如果两个对象都为null，则认为相等</li>
     *   <li>如果其中一个对象为null，另一个不为null，则认为不相等</li>
     *   <li>如果两个对象都不为null，则通过{@link Object#equals(Object)}方法判断是否相等</li>
     * </ul>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的对象相等性校验</li>
     *   <li>多参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void validatePassword(String expected, String actual) {
     *     Assert.notEquals(expected, actual, "密码不正确");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void validateUser(User expected, User actual) {
     *     Assert.notEquals(expected, actual, "用户信息验证失败");
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param obj1 待比较的第一个对象
     * @param obj2 待比较的第二个对象
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当两个对象不相等时抛出
     */
    public static void notEquals(Object obj1, Object obj2, String message) {
        if (obj1 == null && obj2 == null) {
            return;
        }
        if (obj1 == null || obj2 == null) {
            throw new IllegalArgumentException(message);
        }
        if (!obj1.equals(obj2)) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验字符序列不为null且不为空
     * 
     * <p>当传入的字符序列对象为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "the char sequence must not be null or empty"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验方法参数中的字符序列类型</li>
     *   <li>确保字符序列包含至少一个字符</li>
     *   <li>字符串处理、文本分析等业务逻辑校验</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验字符串参数不为空
     * public void processText(String text) {
     *     Assert.notEmpty(text);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验字符序列至少包含一个字符
     * public void analyzeText(CharSequence text) {
     *     Assert.notEmpty(text);
     *     // 文本分析逻辑
     * }
     * }</pre>
     * 
     * @param cs 待校验的字符序列对象
     * @throws IllegalArgumentException 当字符序列为null或为空时抛出
     */
    public static void notEmpty(CharSequence cs) {
        notEmpty(cs , "the char sequence must not be null or empty");
    }

    /**
     * 校验字符序列不为null且不为空（支持自定义错误消息）
     * 
     * <p>当传入的字符序列对象为null或长度为0时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的字符序列校验</li>
     *   <li>多字符序列参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processText(String text) {
     *     Assert.notEmpty(text, "文本内容不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void compareTexts(String text1, String text2) {
     *     Assert.notEmpty(text1, "第一个文本不能为空");
     *     Assert.notEmpty(text2, "第二个文本不能为空");
     *     // 比较逻辑
     * }
     * }</pre>
     * 
     * @param cs 待校验的字符序列对象
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当字符序列为null或为空时抛出
     */
    public static void notEmpty(CharSequence cs , String message) {
        if (cs == null || cs.length() == 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验字符序列不为null、空或仅包含空白字符
     * 
     * <p>当传入的字符序列对象为null、长度为0或仅包含空白字符（如空格、制表符、换行符等）时，
     * 抛出IllegalArgumentException异常，异常消息为默认值
     * "the char sequence must not be null or blank"。</p>
     * 
     * <h3>校验规则：</h3>
     * <ul>
     *   <li>字符序列不能为null</li>
     *   <li>字符序列的长度必须大于0</li>
     *   <li>字符序列不能仅包含空白字符（如" "、"\t"、"\n"等）</li>
     * </ul>
     * 
     * <h3>与notEmpty方法的区别：</h3>
     * <ul>
     *   <li>notEmpty只检查字符序列是否为null或长度为0</li>
     *   <li>notBlank还会检查字符序列是否仅包含空白字符</li>
     * </ul>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验用户输入的文本内容（必须包含可见字符）</li>
     *   <li>校验配置参数（不能为空或仅包含空白字符）</li>
     *   <li>校验任何形式的字符序列对象（String、StringBuilder等）</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验用户名不为空（不能仅包含空格）
     * public void processUser(String username) {
     *     Assert.notBlank(username); // "   "这样的字符串是无效的
     *     // 继续处理逻辑
     * }
     * 
     * // 校验配置参数
     * public void configure(String host, String port) {
     *     Assert.notBlank(host);
     *     Assert.notBlank(port);
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param cs 待校验的字符序列对象
     * @throws IllegalArgumentException 当字符序列为null、空或仅包含空白字符时抛出
     */
    public static void notBlank(CharSequence cs) {
        if (cs == null || cs.length() == 0 || cs.toString().trim().isEmpty()) {
            throw new IllegalArgumentException("the char sequence must not be null or blank");
        }
    }
    
    
    /**
     * 校验字符序列不为null、空或仅包含空白字符（支持自定义错误消息）
     * 
     * <p>当传入的字符序列对象为null、长度为0或仅包含空白字符（如空格、制表符、换行符等）时，
     * 抛出IllegalArgumentException异常，异常消息为指定的自定义消息。</p>
     * 
     * <h3>校验规则：</h3>
     * <ul>
     *   <li>字符序列不能为null</li>
     *   <li>字符序列的长度必须大于0</li>
     *   <li>字符序列不能仅包含空白字符（如" "、"\t"、"\n"等）</li>
     * </ul>
     * 
     * <h3>与notEmpty方法的区别：</h3>
     * <ul>
     *   <li>notEmpty只检查字符序列是否为null或长度为0</li>
     *   <li>notBlank还会检查字符序列是否仅包含空白字符</li>
     * </ul>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>需要提供具体错误信息的字符序列校验</li>
     *   <li>多字符序列参数校验时区分不同的校验点</li>
     *   <li>业务相关错误信息提示</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 提供具体的错误信息
     * public void processUser(String username) {
     *     Assert.notBlank(username, "用户名不能为空");
     *     // 继续处理逻辑
     * }
     * 
     * // 在不同场景下提供不同的错误信息
     * public void configure(String host, String port) {
     *     Assert.notBlank(host, "主机地址不能为空");
     *     Assert.notBlank(port, "端口号不能为空");
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param cs 待校验的字符序列对象
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当字符序列为null、空或仅包含空白字符时抛出
     */
    public static void notBlank(CharSequence cs, String message) {
        if (cs == null || cs.length() == 0 || cs.toString().trim().isEmpty()) {
            throw new IllegalArgumentException(message);
        }
    }


    /**
     * 校验布尔表达式为true
     * 
     * <p>当传入的布尔表达式为false时，抛出IllegalArgumentException异常，
     * 异常消息为默认值"the expression must be true"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验业务逻辑前置条件</li>
     *   <li>验证状态条件</li>
     *   <li>确保业务规则得到满足</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验用户年龄是否满足要求
     * public void processUser(int age) {
     *     Assert.isTrue(age >= 18);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验账户余额是否充足
     * public void withdraw(double amount, double balance) {
     *     Assert.isTrue(balance >= amount);
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param expression 待校验的布尔表达式
     * @throws IllegalArgumentException 当布尔表达式为false时抛出
     */
    public static void isTrue(boolean expression) {
        isTrue(expression , "the expression must be true");
    }

    /**
     * 校验布尔表达式为true
     * 
     * <p>当传入的布尔表达式为false时，抛出IllegalArgumentException异常，
     * 异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验业务逻辑前置条件</li>
     *   <li>验证状态条件</li>
     *   <li>确保业务规则得到满足</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验用户年龄是否满足要求
     * public void processUser(int age) {
     *     Assert.isTrue(age >= 18, "用户年龄必须大于等于18岁");
     *     // 继续处理逻辑
     * }
     * 
     * // 校验账户余额是否充足
     * public void withdraw(double amount, double balance) {
     *     Assert.isTrue(balance >= amount, "账户余额不足");
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param expression 待校验的布尔表达式
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当布尔表达式为false时抛出
     */
    public static void isTrue(boolean expression, String message) {
        if (!expression) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 校验布尔表达式为false
     * 
     * <p>当传入的布尔表达式为true时，抛出IllegalArgumentException异常，
     * 异常消息为默认值"the expression must be false"。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验业务逻辑前置条件</li>
     *   <li>验证状态条件</li>
     *   <li>确保业务规则得到满足</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验用户是否未被锁定
     * public void processUser(boolean isLocked) {
     *     Assert.isFalse(isLocked);
     *     // 继续处理逻辑
     * }
     * 
     * // 校验文件是否未被删除
     * public void processFile(boolean isDeleted) {
     *     Assert.isFalse(isDeleted);
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param expression 待校验的布尔表达式
     * @throws IllegalArgumentException 当布尔表达式为true时抛出
     */
    public static void isFalse(boolean expression) {
        isFalse(expression , "the expression must be false");
    }

    /**
     * 校验布尔表达式为false
     * 
     * <p>当传入的布尔表达式为true时，抛出IllegalArgumentException异常，
     * 异常消息为指定的自定义消息。</p>
     * 
     * <h3>使用场景：</h3>
     * <ul>
     *   <li>校验业务逻辑前置条件</li>
     *   <li>验证状态条件</li>
     *   <li>确保业务规则得到满足</li>
     * </ul>
     * 
     * <h3>使用示例：</h3>
     * <pre>{@code
     * // 校验用户是否未被锁定
     * public void processUser(boolean isLocked) {
     *     Assert.isFalse(isLocked, "用户账户已被锁定");
     *     // 继续处理逻辑
     * }
     * 
     * // 校验文件是否未被删除
     * public void processFile(boolean isDeleted) {
     *     Assert.isFalse(isDeleted, "文件已被删除");
     *     // 继续处理逻辑
     * }
     * }</pre>
     * 
     * @param expression 待校验的布尔表达式
     * @param message 自定义错误消息
     * @throws IllegalArgumentException 当布尔表达式为true时抛出
     */
    public static void isFalse(boolean expression, String message) {
        if (expression) {
            throw new IllegalArgumentException(message);
        }
    }
}